package com.woniu.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

@Component
public class RabbitmqConfig {
    /**
     * 定义检查订单状态的队列
     * @return
     */
    @Bean
    public Queue checkOrder(){
        return QueueBuilder.durable("checkOrder").build();
    }

    @Bean
    public Queue addSecKill(){
        return QueueBuilder.durable("addSecKill").build();
    }
    @Bean
    public Queue delSecKill(){
        return QueueBuilder.durable("delSecKill").build();
    }

    @Bean
    public CustomExchange customExchange(){
        Map map = new HashMap();
        //指定交换机类型
        map.put("x-delayed-type","direct");
        /**
         * 参数1：交换机的名字
         * 参数2：消息的类型，延迟消息
         * 参数3：是否持久化，在 rabbit关闭后，再打开该交换机还在不在
         * 参数4：是否自动删除，当没有队列绑定该交换机时，是否删除历史
         * 参数5：初始化参数，比如指定交换机类型
         */
        return new CustomExchange("customExchange","x-delayed-message",
                true,false,map);

    }

    @Bean
    public Binding checkOrderQueueTocustomExchange(Queue checkOrder,CustomExchange customExchange){
        return BindingBuilder.bind(checkOrder).to(customExchange).with("checkOrder").noargs();
    }

    @Bean
    public Binding addSecKillBookTocustomExchange(Queue addSecKill,CustomExchange customExchange){
        return BindingBuilder.bind(addSecKill).to(customExchange).with("addSecKill").noargs();
    }
    @Bean
    public Binding delSecKillBookTocustomExchange(Queue delSecKill,CustomExchange customExchange){
        return BindingBuilder.bind(delSecKill).to(customExchange).with("delSecKill").noargs();
    }

    // 主题模式的队列（topic）
    @Bean
    public Queue addKillOrderQueue(){
        return QueueBuilder.durable("addKillOrderQueue").build();
    }
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange("topicExchange");
    }
    @Bean
    public Binding addKillOrderQueueTotopicExchange(Queue addKillOrderQueue,TopicExchange topicExchange){
        return BindingBuilder.bind(addKillOrderQueue).to(topicExchange).with("#.order");
    }

    //外卖的队列
    @Bean
    public Queue cancelFoodOrderQueue(){
        return QueueBuilder.durable("cancelFoodOrderQueue").build();
    }
    @Bean
    public CustomExchange foodExchange(){
        Map map = new HashMap();
        //指定交换机类型
        map.put("x-delayed-type","direct");
        /**
         * 参数1：交换机的名字
         * 参数2：消息的类型，延迟消息
         * 参数3：是否持久化，在 rabbit关闭后，再打开该交换机还在不在
         * 参数4：是否自动删除，当没有队列绑定该交换机时，是否删除历史
         * 参数5：初始化参数，比如指定交换机类型
         */
        return new CustomExchange("foodExchange","x-delayed-message",
                true,false,map);
    }
    @Bean
    public Binding cancelFoodOrderQueueToFoodExchange(Queue cancelFoodOrderQueue,CustomExchange foodExchange){
        return BindingBuilder.bind(cancelFoodOrderQueue).to(foodExchange).with("food").noargs();
    }

    //延迟添加秒杀活动
    @Bean
    public Queue addSecActiveQueue(){
        return QueueBuilder.durable("addSecActiveQueue").build();
    }
    @Bean
    public CustomExchange secActiveExchange(){
        Map map = new HashMap();
        //指定交换机类型
        map.put("x-delayed-type","direct");
        /**
         * 参数1：交换机的名字
         * 参数2：消息的类型，延迟消息
         * 参数3：是否持久化，在 rabbit关闭后，再打开该交换机还在不在
         * 参数4：是否自动删除，当没有队列绑定该交换机时，是否删除历史
         * 参数5：初始化参数，比如指定交换机类型
         */
        return new CustomExchange("secActiveExchange","x-delayed-message",
                true,false,map);
    }
    @Bean
    public Binding addSecActiveQueueToSecActiveExchange(Queue addSecActiveQueue,CustomExchange secActiveExchange){
        return BindingBuilder.bind(addSecActiveQueue).to(secActiveExchange).with("addKill").noargs();
    }
}
